Deployment.c

Go to the documentation of this file.

#include "derivative.h"
#include "Compile_Options.h"
#include "Deployment.h"
#include "SM.h"
#include "SBC_AL.h"
#include "HAL.h"
#include "MailScheduler.h"
#include "Application_Globals.h"
#include "SIU.h"
#ifdef USE_LABVIEW
#include "Labview.h"
#endif
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
const uint16_t cau16PreDeploymentValidStates[] =
{
  SM_STATE_ERROR, SM_STATE_DECISION };
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
/*
 ******************************************************************************
 * u32fnStateDeployment
 ******************************************************************************
 */
uint32_t u32fnStateDeployment(void)
{
  uint32_t u32Status;
  uint16_t u16TrueDeploymentSquibs;
  uint8_t u8NextState;
  
  u8NextState = CLEAR;
  
  /* Verify that we can execute - Previous state ended correctly */
  u32Status
      = u32fnSMValidateCurrentState((uint16_t*)cau16PreDeploymentValidStates,
                                    N_ELEMENTS(cau16PreDeploymentValidStates));
  if(CLEAR == u32Status)
  {
    /* Here comes the real contents of the state */
    LOCK_STATE_EXECUTION();
    
    /* Figure out which squibs we really need to fire since we don't */
    /* want to have refiring */
    u16TrueDeploymentSquibs = (uint16_t)(gu16SquibsToFire & ~gu16FiredSquibs);
    
    /* Here below lies the most dangerous line in all of the project */
    /* This call fires squibs */
    u32Status = u32fnSBCFireSquibs(u16TrueDeploymentSquibs);
    
    if(CLEAR == u32Status)
    {
      /* Next we start figuring out what just happened */
      u32Status = u32fnDeploymentStatusReport(u16TrueDeploymentSquibs,
                                              (uint16_t*)&gu16FiredSquibs,
                                              (uint8_t*)&u8NextState);
      
      /* Only continue if there was a deployment or lack of it */
      if(CLEAR != u32Status)
      {
        /*-- CAN messages and others will go here --*/
      }
      else
      {
        /* We can leave now */
      }
    }
    else
    {
      /* Get out with the current error */
    }
    
  }
  else
  {
    /* Leave */
  }

  /* Set the next state */
  if(CLEAR == u32Status)
  {
    vfnSMWriteNextState(u8NextState);
  }
  else
  {
    vfnSMWriteNextState(SM_STATE_ERROR);
  }
  
  /* Unlock the state */
  UNLOCK_STATE_EXECUTION();
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnDeploymentStatusReport
 ******************************************************************************
 */
uint32_t u32fnDeploymentStatusReport(const uint16_t cu16ExpectedFiring,
                                     uint16_t* pu16FiredSquibs,
                                     uint8_t* pu8NextState)
{
  /* Declare locals */
  uint32_t u32Status;
  uint16_t u16FiredSquibsCopy;
#ifdef USE_LABVIEW
  uint8_t u8LabviewStatus;
#endif
  
  /* Init locals */
  u16FiredSquibsCopy = *pu16FiredSquibs;
  u32Status = CLEAR;
  
  /* We need to figure out what just happened. First, collect which   */
  /* Squibs were fired, if any.                                       */
  u32Status = u32fnSBCSquibFiringStatus(pu16FiredSquibs);
  
  if(CLEAR == u32Status)
  { 
    /* Were all selected channels fired? */
    u32Status = (uint32_t)((cu16ExpectedFiring & ~(*pu16FiredSquibs)));
    
    /* Check if at least one squib was fired */
    if(CLEAR == *pu16FiredSquibs)
    {
      /* Nothing happened - We can leave */
      *pu8NextState =  SM_STATE_GUI;
    }
    else
    {
      /* If there was at least one fired squib, we need to act accordingly */
      /* Turn on the warning lamp */
      (void)u8fnSBCEnableWarningLamp(TRUE);

      /* Remove the satellite from the list of active satellites */
      gu16ActivePSI5Channels &= ~gu16ConfirmedSatellites;
      
      /* Do the same thing for the squibs */
      gu16ActiveSquibChannels &= ~(*pu16FiredSquibs);
      
#ifdef USE_LABVIEW
      vfnGUISendDeploymentEvent();
#endif
      
      /* Depending on whether we have some functionality left or not, */
      /* we will decide were to go next                               */
      if((CLEAR < gu16ActiveSquibChannels) & (CLEAR < gu16ActivePSI5Channels))
      {
        /* Jump directly to Acquisition state */
        *pu8NextState = SM_APPLICATION_START;
      }
      else
      {
        /* We can't possibly do anything else. Flag it as an error and exit */
        u32Status = DEPLOYMENT_ERR_SAT_AND_SQUIBS_DEPLOYED;
        *pu8NextState = SM_STATE_ERROR;
      }
    }
  }
  else
  {
    /* Get out */
  }
  
  /* Remember all fired squibs, even those from previous occasions */
  *pu16FiredSquibs |= u16FiredSquibsCopy;
  
  return(u32Status);
}
#ifdef USE_LABVIEW
/* This section is for demo purposes only and should be removed in a */
/* real application */
void vfnGUISendDeploymentEvent(void)
{
  uint8_t u8LabviewStatus;
  uint16_t au16LabviewData[6u];
  
  /* We will enable Serial communication */
  vfnLVEnable(TRUE);
  
  /* Construct a new message */
  au16LabviewData[0u] = gau16RawAccels[0u];
  au16LabviewData[1u] = gau16RawAccels[3u];
  au16LabviewData[2u] = gau16RawAccels[6u];
  au16LabviewData[3u] = gau16RawAccels[9u];
  au16LabviewData[4u] = gau16RawAccels[12u];
  au16LabviewData[5u] = gau16RawAccels[13u];
  
  /* And wait for any on-going transmission to finish */
  u8LabviewStatus = u8fnLVWaitForTxPort();
  
  /* Send latest acceleration */
  vfnDisplaySCIData(LV_DA_MSG, LV_16, 6u, 1u,
                   (uint8_t*)au16LabviewData);
  
  /* And send event */
  vfnLVTriggerEvent();
  return;
}
#endif
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */